package org.dromara.common.encrypt.interceptor;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.resultset.ResultSetHandler;
import org.apache.ibatis.plugin.*;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.encrypt.annotation.EncryptField;
import org.dromara.common.encrypt.core.EncryptContext;
import org.dromara.common.encrypt.core.EncryptorManager;
import org.dromara.common.encrypt.enumd.AlgorithmType;
import org.dromara.common.encrypt.enumd.EncodeType;
import org.dromara.common.encrypt.properties.EncryptorProperties;

import java.lang.reflect.Field;
import java.sql.Statement;
import java.util.*;


/**
 * @Author 刘武贵
 * @Date 2024/8/15 22:00
 * @Description 功能描述：出参解密拦截器
 */
@Slf4j
// 定义一个拦截器，用于在MyBatis处理结果集时进行拦截操作
@Intercepts({@Signature(
    // 拦截的目标类型为ResultSetHandler，处理数据库查询结果集
    type = ResultSetHandler.class,
    // 被拦截的方法名为handleResultSets，用于处理多个结果集
    method = "handleResultSets",
    // 方法的参数类型为Statement类，表示SQL语句执行的结果
    args = {Statement.class})
})
@AllArgsConstructor
/**
 * 实现Interceptor接口的加密字段拦截器类
 * 该拦截器用于在Mybatis操作数据库时，自动处理指定字段的加解密工作
 * 主要目的是为了保护敏感数据的安全，避免直接以明文形式存储在数据库中
 */
public class MybatisDecryptInterceptor implements Interceptor {

    /**
     * 加密管理类
     */
    private final EncryptorManager encryptorManager;

    /**
     * 加解密属性配置类
     */
    private final EncryptorProperties defaultProperties;

    /**
     * 拦截器方法，用于在执行方法前后进行拦截操作
     * 主要用于处理方法执行前后的逻辑，本例中主要用于处理方法执行结果
     *
     * @param invocation 用于执行被拦截的方法调用对象，包含方法执行的相关信息
     * @return 返回执行结果，如果结果为null，则返回null
     * @throws Throwable 如果执行过程中出现异常，将抛出Throwable异常
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 获取执行mysql执行结果
        Object result = invocation.proceed();
        if (result == null) {
            return null;
        }
        // 对执行结果进行解密处理
        decryptHandler(result);
        return result;
    }

    /**
     * 解密对象
     * 递归处理对象中的加密字段，实现解密
     *
     * @param sourceObject 待加密对象，可以是Map、List或普通对象
     */
    private void decryptHandler(Object sourceObject) {
        if (ObjectUtil.isNull(sourceObject)) {
            return;
        }

        // 如果对象是Map类型，递归处理其所有值
        if (sourceObject instanceof Map<?, ?> map) {
            new HashSet<>(map.values()).forEach(this::decryptHandler);
            return;
        }

        // 如果对象是List类型，检查并递归处理
        if (sourceObject instanceof List<?> list) {
            if(CollUtil.isEmpty(list)) {
                return;
            }
            // 判断第一个元素是否含有注解。如果没有直接返回，提高效率
            Object firstItem = list.get(0);
            if (ObjectUtil.isNull(firstItem) || CollUtil.isEmpty(encryptorManager.getFieldCache(firstItem.getClass()))) {
                return;
            }
            list.forEach(this::decryptHandler);
            return;
        }
        // 不在缓存中的类,就是没有加密注解的类(当然也有可能是typeAliasesPackage写错)
        // 获取当前对象类中需要解密的字段集合，不在缓存中的类是没有加密注解的类
        Set<Field> fields = encryptorManager.getFieldCache(sourceObject.getClass());
        if(ObjectUtil.isNull(fields)){
            return;
        }

        // 尝试解密每个需要解密的字段
        try {
            for (Field field : fields) {
                // 使用解密方法解密字段值，并更新回原对象
                field.set(sourceObject, this.decryptField(Convert.toStr(field.get(sourceObject)), field));
            }
        } catch (Exception e) {
            log.error("处理解密字段时出错", e);
        }
    }

    /**
     * 字段值进行加密。通过字段的批注注册新的加密算法
     * 解密字段值
     * 此方法用于解密带有EncryptField注解的字段值
     * 它首先检查传入的值是否为空，如果为空，则直接返回null
     * 否则，它会根据字段上的EncryptField注解配置和默认属性来创建EncryptContext对象
     * EncryptContext对象包含了进行解密操作所需的各种参数，如算法、编码方式、密码等
     * 最后，使用EncryptContext对象调用encryptorManager的decrypt方法来实现解密
     *
     * @param value 待加密的值
     * @param field 待加密字段，用于获取注解信息
     * @return 加密后结果
     */
    private String decryptField(String value, Field field) {
        if (ObjectUtil.isNull(value)) {
            return null;
        }
        EncryptField encryptField = field.getAnnotation(EncryptField.class);
        // 初始化加密上下文，用于设置加密算法、编码方式等参数
        EncryptContext encryptContext = new EncryptContext();
        encryptContext.setAlgorithm(encryptField.algorithm() == AlgorithmType.DEFAULT ? defaultProperties.getAlgorithm() : encryptField.algorithm());
        encryptContext.setEncode(encryptField.encode() == EncodeType.DEFAULT ? defaultProperties.getEncode() : encryptField.encode());
        encryptContext.setPassword(StringUtils.isBlank(encryptField.password()) ? defaultProperties.getPassword() : encryptField.password());
        encryptContext.setPrivateKey(StringUtils.isBlank(encryptField.privateKey()) ? defaultProperties.getPrivateKey() : encryptField.privateKey());
        encryptContext.setPublicKey(StringUtils.isBlank(encryptField.publicKey()) ? defaultProperties.getPublicKey() : encryptField.publicKey());
        // 调用加密器管理器的解密方法，返回解密后的值
        return this.encryptorManager.decrypt(value, encryptContext);
    }

    /**
     * 对目标对象进行插件增强
     * 该方法通过Wrap代理模式，将当前插件实例注入到目标对象中，从而实现对目标对象的功能增强
     *
     * @param target 目标对象，需要被增强的对象
     * @return 返回经过增强后的代理对象
     */
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    /**
     * 设置插件的属性
     * 该方法通过读取属性文件，将其中的属性应用到插件实例上，以便在插件执行时能够使用这些属性
     *
     * @param properties 属性文件，包含了插件所需的各项配置
     */
    @Override
    public void setProperties(Properties properties) {

    }
}
